try
{

    /**
     * All finders start from the Browser object; the TestFire user ( building the test set ) will choose the
     * actual object of interest (TD, TR, Button etc) and we build the xml to actually find the object.
     *
     * This isn't generally hard; with the exception of Frames (and IFrames) we can use the XPATH. Frames are
     * much, much more annoying.
     */
    HtmlFinder = {
        finder: null,
        button: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        cell: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        checkbox: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        div: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        fileField: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        form: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        frame: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: "",
            keyType: 'Frame',
            getVariableKey: function( testFire, args )
            {
                return 'frame' ;
            },
            getObjectKey: function( testFire, args )
            {
                var objKey;
                if(args.depth === args.maxDepth)
                {
                    /* is this the topmost frame? If so, use the default object key. */
                    objKey = args.objKey;
                }
                else{
                    objKey = 'frame';
                }
                return objKey;

            }},
        hidden: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        htmlElement: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        image: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        label: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        link: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        option: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        radio: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        row: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        selectList: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        span: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        textField: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        body: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},

    /**
     * Utility function: takes a string and a set of key:value pairs and appends the key:value pairs to the string.
     */
        addAttrs: function( str, attrs )
        {
            for ( var name in attrs )
            {
                var attr = this.escapeQuotes(attrs[name]);
                str += " " + name + '="' + attr + '"';
            }
            return str
        },
        xmlEncode: function ( value )
        {
            if ( !value )
                return value;
            else
                return String(value).replace(/&/g, "&amp;").replace(/>/g, "&gt;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
        },

        bindFixed: function()
        {
            try
            {
                var args = FBL.cloneArray(arguments), fn = args.shift(), object = args.shift();
                return function()
                {
                    try
                    { return fn.apply(object, FBL.extendArray(args, arguments));}
                    catch( ex )
                    {tf_debug(ex); }
                }
            }
            catch( ex )
            { Firebug.TestFire.util.tf_debug(ex); }

        },
        escapeHTML: function( str )
        {
            return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
        },



        escapeQuotes: function ( str )
        {
            return this.xmlEncode(str);
        },


        getHtmlFinder: function( element )
        {
            var finder = null;
            if ( element && element.localName )
            {
                var localName = element.localName.toLowerCase();
                finder = HTML_FINDER_MAP[localName];
                if ( !finder )
                {
                    alert("Finder for element type '" + localName + "' not yet implemented.");
                    return null;
                }
                if ( finder == INPUT_TYPE_MAP )
                {
                    finder = INPUT_TYPE_MAP[element.type];
                }
            }
            return finder;
        },



        createMenuItem: function( finder, name, fromObj, testFireObj )
        {
            try
            {
                var ary;
                if ( finder[name].assertable != 0 )
                {
                    ary = this.createAssertableMenuItems(finder, name, fromObj, testFireObj);
                    var menuLabel = finder[name].displayKey != "" ? finder[name].displayKey : name;
                    return {label: menuLabel, menuItems: ary };
                }
                else if ( finder[name].actionable != 0 )
                {
                    return this.createActionableMenuItems(finder, name, fromObj, testFireObj);
                }

            }
            catch( ex )
            {
                Firebug.TestFire.util.tf_debug(ex);
            }
        },

        createActionableMenuItems: function( finder, finderName, fromObj, testFireObj )
        {
            var cmd = new Actionable(testFireObj, finderName);
            return  { nol10n: 1, label: finderName, command: this.bindFixed(testFireObj.doAddActionable,
                testFireObj, fromObj, finder, finderName, cmd) };
        },

        createAssertableMenuItems: function( finder, finderName, fromObj, testFireObj )
        {
            var ary = new Array();
            var asserts = finder[finderName].assertable;
            var assert;
            if ( ( ASSERT_BOOLEAN_EQ & asserts) == ASSERT_BOOLEAN_EQ )
            {
                assert = new assertBooleanEquals();
                ary.push({ nol10n: 1, label: assert.displayValue, command: this.bindFixed(testFireObj.doAddAssertion,
                    testFireObj, fromObj, finder, finderName, assert)});
            }
            if ( (ASSERT_BYTE_EQ & asserts ) == ASSERT_BYTE_EQ )
            {
                assert = new assertByteEquals();
                ary.push({ nol10n: 1, label: assert.displayValue, command: this.bindFixed(testFireObj.doAddAssertion,
                    testFireObj, fromObj, finder, finderName, assert)});
            }
            if ( (ASSERT_CHAR_EQ & asserts ) == ASSERT_CHAR_EQ )
            {
                assert = new assertCharEquals();
                ary.push({ nol10n: 1, label: assert.displayValue, command: this.bindFixed(testFireObj.doAddAssertion,
                    testFireObj, fromObj, finder, finderName, assert)});
            }
            if ( (ASSERT_DOUBLE_EQ & asserts ) == ASSERT_DOUBLE_EQ )
            {
                assert = new assertDoubleEquals();
                ary.push({ nol10n: 1, label: assert.displayValue, command: this.bindFixed(testFireObj.doAddAssertion,
                    testFireObj, fromObj, finder, finderName, assert)});
            }
            if ( (ASSERT_INT_EQ & asserts ) == ASSERT_INT_EQ )
            {
                assert = new assertIntegerEquals();
                ary.push({ nol10n: 1, label: assert.displayValue, command: this.bindFixed(testFireObj.doAddAssertion,
                    testFireObj, fromObj, finder, finderName, assert)});
            }
            if ( (ASSERT_OBJECT_EQ & asserts ) == ASSERT_OBJECT_EQ )
            {
                assert = new assertObjectEquals();
                ary.push({ nol10n: 1, label: assert.displayValue, command: this.bindFixed(testFireObj.doAddAssertion,
                    testFireObj, fromObj, finder, finderName, assert)});
            }
            if ( (ASSERT_STRING_EQ & asserts ) == ASSERT_STRING_EQ )
            {
                assert = new assertStringEquals();
                ary.push({ nol10n: 1, label: assert.displayValue, command: this.bindFixed(testFireObj.doAddAssertion,
                    testFireObj, fromObj, finder, finderName, assert)});
            }
            if ( (ASSERT_FALSE & asserts ) == ASSERT_FALSE )
            {
                assert = new assertFalse();
                ary.push({ nol10n: 1, label: assert.displayValue  });
            }
            if ( (ASSERT_NOT_NULL & asserts ) == ASSERT_NOT_NULL )
            {
                assert = new assertNotNull();
                ary.push({ nol10n: 1, label: assert.displayValue, command: this.bindFixed(testFireObj.doAddAssertion,
                    testFireObj, fromObj, finder, finderName, assert)});
            }
            if ( (ASSERT_NULL & asserts ) == ASSERT_NULL )
            {
                assert = new assertNull();
                ary.push({ nol10n: 1, label: assert.displayValue, command: this.bindFixed(testFireObj.doAddAssertion,
                    testFireObj, fromObj, finder, finderName, assert)});
            }
            if ( (ASSERT_NOT_SAME & asserts ) == ASSERT_NOT_SAME )
            {
                assert = new assertNotSame();
                ary.push({ nol10n: 1, label: assert.displayValue, command: this.bindFixed(testFireObj.doAddAssertion,
                    testFireObj, fromObj, finder, finderName, assert)});
            }
            if ( (ASSERT_SAME & asserts ) == ASSERT_SAME )
            {
                assert = new assertSame();
                ary.push({ nol10n: 1, label: assert.displayValue, command: this.bindFixed(testFireObj.doAddAssertion,
                    testFireObj, fromObj, finder, finderName, assert)});
            }
            if ( (ASSERT_FAIL & asserts ) == ASSERT_FAIL )
            {
                assert = new fail();
                ary.push({ nol10n: 1, label: assert.displayValue, command: this.bindFixed(testFireObj.doAddAssertion,
                    testFireObj, fromObj, finder, finderName, assert)});
            }
            if ( (ASSERT_TRUE & asserts ) == ASSERT_TRUE )
            {
                assert = new assertTrue();
                ary.push({ nol10n: 1, label: assert.displayValue, command: this.bindFixed(testFireObj.doAddAssertion,
                    testFireObj, fromObj, finder, finderName, assert)});
            }

            return ary;

        }
    }

    /**
     * Each element extending HtmlElement declares a few tidbits:
     * 1.) assertable: boolean ( 0 | 1)
     *          Is this an assertable command? An assertion type, such as 'assertEqual' etc.
     * 2.) actionable: boolean (0 | 1)
     *          Is this an action command, such as set?
     * 3.) addToMenu: boolean ( 0 | 1)
     *          If this item should be added to menus, where appropriate; this is to disable commands that aren't
     *          implemented, but I haven't disabled any at the moment.
     * 4.) displayKey: String
     *          The PURPOSE of this is I18N, one day. Does nothing now. Might be implmented in better ways, who knows.
     * [ remaining are optional, depending on the type ]
     * 5.) required: {attributeOne: value, attributeTwo: value2 }
     *      Any attributes required by the HtmlElement Command / Assertion. For instance, 'set' requires the value
     *      that the element will be set to.
     * 6.) getAttributeValues: function(target)
     *      Retrieve the required element values from the target element. For instance, 'set' only makes sense on input
     *      elements; the target passed should already have been tested for this, the requirement of
     *      getAttributeValues is to get the values off of the element and set them on 'this', and then return the
     *      pseudo array object.
     * ----------------------------
     *
     *
     * It may be better to treat these as singleton entities and always/only use the return values from method calls.
     *
     * Also, doing so might make it easier to generify the parsing/returning of values by using the 'required' object
     * as a mapping between the xml and the accessor on 'target' (the element). For instance, again using set:
     *
     * required: { value: 'value' }
     *
     * getAttributeValues(target){
     *      if(target) {
     *              return target[this.required.value]; // try-catch would be wise.
     * }
     *
     * ---------------------
     * An HtmlElement finder on an element action that requires a value:
     * set: {
     *      assertable: 0,
     *      actionable: 1,
     *      addToMenu: 1,
     *      displayKey: "",
     *      required: {value: "" },
     *      getAttributeValues: function(target)
     *      {
     *          if(target && target.tagName.toLowerCase() == 'input')
     *          {
     *              return {value: target.value };
     *          }
     *          return { value: this.required.value };
     *      }
     *
     *  },
     * The resulting XML
     * <tf:ElementAction useObjectKey="engine">
     *          <tf:textField>
     *                  <tf:Finder>
     *                          <tf:title value="Google Search" />
     *                  </tf:Finder>
     *                  <tf:set value="Test" />
     *          </tf:textField>
     *  </tf:ElementAction>
     *
     *
     *
     */

    HtmlElement = domplate(HtmlFinder, {
        _type: 'htmlElement',
        className: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 1,
            displayKey: "",
            required: {className: "" },
            getAttributeValues: function( target )
            {
                this.required.className = target ? target.className : "";
                return { value: this.required.className };
            }
        },
        click: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        dblClick: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        disabled: {
            assertable: ASSERT_SET_BOOL,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""
        },
        enabled: {
            assertable: ASSERT_SET_BOOL,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        exists: {
            assertable: ASSERT_SET_BOOL,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""
        },
        fireEvent: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: "",
            required: {jsEvent: "click" },
            getAttributeValues: function( target )
            {
                window.openDialog("chrome://TestFireExtension/content/dialogs/getRequiredValueDialog.xul",
                    "GetValue", "chrome, dialog, modal, resizable=yes,centerscreen",
                    this, "What JavaScript event should be fired?");
                return { value: this.required.jsEvent };
            },
            doSetRequiredValue: function( dialog )
            {
                this.required.jsEvent = dialog.document.getElementById("value").value;
                return true;
            },
            doCancel: function( dialog )
            {
                return true;
            }

        },
        flash: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        focus: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        getOLEObject: {
            assertable: ASSERT_OBJECT_EQ | ASSERT_NOT_NULL | ASSERT_NULL,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        html: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        id: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        innerText: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        name: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        show: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        style: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        text: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        title: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        type: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        value: {
            assertable: ASSERT_SET_VALUE,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""}
    });

    Span = domplate(HtmlElement, {
        _type: 'span'

    })

    TextField = domplate(HtmlElement, {
        _type: 'textField',
        append: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: "",
            required: {value: "" },
            getAttributeValues: function( target )
            {
                if ( target && target.tagName.toLowerCase() == 'input' )
                {
                    return {value: target.value };
                }
                return { value: this.required.value };
            }

        },
        assertNotReadOnly: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        clear: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        dragContentsTo: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        getContents: {
            assertable: ASSERT_SET_VALUE,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        maxLength: {
            assertable: ASSERT_INT_EQ,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        readOnly: {
            assertable: ASSERT_SET_BOOL,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        set: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: "",
            required: {value: "" },
            getAttributeValues: function( target )
            {
                if ( target && target.tagName.toLowerCase() == 'input' )
                {
                    return {value: target.value };
                }
                return { value: this.required.value };
            }

        },
        size: {
            assertable: ASSERT_INT_EQ,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        verifyContains: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        toXmlStringAry: function( element, childXmlElements )
        {
            // element.localName == 'textfield' (known)
            var ary = new Array();

        }

    });

    FileField = domplate(TextField, {
        _type: 'fileField'

    })

    Hidden = domplate(TextField, {
        _type: 'hidden'
    })

    TextArea = domplate(TextField, {
        _type: 'textField',
        value: {
            assertable: ASSERT_SET_VALUE,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""}
    })

    Button = domplate(HtmlElement, {
        _type: 'button'
    })

    Link = domplate(HtmlElement, {
        _type: 'link',
        href: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        linkHasImage: {
            assertable: ASSERT_SET_BOOL,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""}
    })

    Label = domplate(HtmlElement, {
        _type: 'label',
        htmlFor: {
            assertable: 0,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""}
    })

    Checkbox = domplate(HtmlElement, {
        _type: 'checkbox',
        clear: {
            assertable: 0,
            actionable: 1,
            addToMenu: 0,
            displayKey: ""},
        getState: {
            assertable: ASSERT_SET_BOOL,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        isSet: {
            assertable: ASSERT_SET_BOOL,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        set: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: "",
            required: {checked: false },
            getAttributeValues: function( target )
            {
                if ( target && target.tagName.toLowerCase() == 'input' && target.type == 'checkbox' )
                {
                    return {value: target.checked };
                }
                return { value: required.checked };
            }
        }
    })

    Radio = domplate(HtmlElement, {
        _type: 'radio',
        clear: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        getState: {
            assertable: ASSERT_SET_BOOL,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        isSet: {
            assertable: ASSERT_SET_BOOL,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        set: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""}
    })

    Option = domplate(HtmlElement, {
        _type: 'option',
        clear: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        select: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        selected: {
            assertable: ASSERT_SET_BOOL,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        set: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""}
    })

    SelectList = domplate(HtmlElement, {
        _type: 'selectList',
        clearSelection: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        getAllContents: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
    /* @todo Returns a list of elements; handle later (Requires some thought) */
        getSelectedItems: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""},
        select: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        selectValue: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""}
    })

    TableBody = domplate(HtmlElement, {
        _type: 'table',
        columnCount: {
            assertable: ASSERT_INT_EQ,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        rowCount: {
            assertable: ASSERT_INT_EQ,
            actionable: 0,
            addToMenu: 0,
            displayKey: ""}
    })

    TableRow = domplate(HtmlElement, {
        _type: 'row',
        cell: {
            assertable: ASSERT_INT_EQ,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        columnCount: {
            assertable: ASSERT_INT_EQ,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""}
    })

    TableCell = domplate(HtmlElement, {
        _type: 'cell',
        colSpan: {
            assertable: ASSERT_INT_EQ,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""}
    })

    Image = domplate(HtmlElement, {
        _type: 'image',
        alt: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        fileCreatedDate: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        fileSize: {
            assertable: ASSERT_INT_EQ,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        hasLoaded: {
            assertable: ASSERT_SET_BOOL,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        height: {
            assertable: ASSERT_INT_EQ,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        save: {
            assertable: 0,
            actionable: 1,
            addToMenu: 0,
            displayKey: ""},
        src: {
            assertable: ASSERT_SET_STRING,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        width: {
            assertable: ASSERT_INT_EQ,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""}
    });

    Frame = domplate(HtmlElement, {
        _type: 'frame',
        containsText: {
            assertable: ASSERT_SET_BOOL,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""}
    })

    Form = domplate(HtmlElement, {
        _type: 'form',
        submit: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""}
    })

    Browser = domplate(HtmlElement, {
        _type: 'Browser',
        active: {
            assertable: 1,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        back: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        bringToFront: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        childBrowser: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: "",
            keyType: 'WatijBrowser',
            /*
            * For our purposes at the moment, we will assume that getVariableKey is ONLY called
            * when the user opens a new window, so that we can use this as the way of tracking
             * the window index.
            */
            getVariableKey: function( testFire, args )
            {
                // increment the current window index and use the value.
                return args.objKey;
            },
            getObjectKey: function( testFire )
            {
                return testFire.lastWindowUsedName;
            }


        },
        childBrowserCount: {
            assertable: 1,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        clearUrlList: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        close: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""

        },
        containsText: {
            assertable: 1,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        executeScript: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        focus: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        foward: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        goTo: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        height: {
            assertable: 1,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        isFront: {
            assertable: 1,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        log: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        maximize: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        minimize: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        navigate: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        refresh: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        restore: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        screenCapture: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        sendKeys: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        setAdditionalHttpHeaders: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        setFastSpeed: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        setSlowSpeed: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        show: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""},
        start: {
            assertable: 0,
            actionable: 1,
            addToMenu: 1,
            displayKey: "",
            required: {url: "localhost" },
            getAttributeValues: function( target )
            {
                if ( target && target.document && target.document.URL )
                {
                    var url = Firebug.TestFire.util.escapeHTML(target.document.URL);
                    return {url: url};
                }
                return { url: required.url };
            }
        },
        status: {
            assertable: 1,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""
        },
        text: {
            assertable: 1,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        title: {
            assertable: 1,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        url: {
            assertable: 1,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        urlList: {
            assertable: 1,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        waitUntil: {
            assertable: 1,
            actionable: 0,
            addToMenu: 1,
            displayKey: ""},
        width: {
            assertable: 1,
            actionable: 1,
            addToMenu: 1,
            displayKey: ""}




    })

    INPUT_TYPE_MAP = {
        hidden: Hidden,
        text: TextField,
        password: TextField,
        checkbox: Checkbox,
        radio: Radio,
        submit: Button,
        button: Button

    }

    HTML_FINDER_MAP = {
        tbody: TableBody,
        tr: TableRow,
        td: TableCell,
        img: Image,
        form: Form,
        input: INPUT_TYPE_MAP,
        label: Label,
        select: SelectList,
        option: Option,
        textarea: TextArea,
        a: Link
    }

}
catch( ex )
{
    Firebug.TestFire.util.tf_debug(ex);
}